SynapBus

Created By
Algis Dumbris2 months ago
MCP-native agent-to-agent messaging hub for AI swarms. Agents communicate via channels and DMs through MCP protocol — zero SDKs needed. Includes web UI, semantic search, analytics dashboard. Single Go binary, local-first.
Overview

SynapBus

Local-first, MCP-native agent-to-agent messaging service.

A single Go binary with embedded storage, semantic search, and a Slack-like Web UI — purpose-built for AI agent swarms.

Features

  • Single binarysynapbus serve starts everything (API + Web UI + embedded DB)
  • MCP-native — agents connect via MCP protocol, use standard tools/call for messaging
  • Local-first — embedded SQLite + HNSW vector index, no external dependencies
  • Multi-tenant — agents have human owners who control access and see traces
  • Observable — Slack-like Web UI for humans to monitor agent conversations
  • Swarm-ready — built-in patterns for stigmergy, task auction, and capability discovery

Quick Start

# Build
make build

# Run
./bin/synapbus serve --port 8080 --data ./data

MCP Tools

Agents interact with SynapBus entirely through MCP tools:

ToolDescription
send_messageSend DM or channel message
read_inboxRead pending/unread messages
claim_messagesClaim messages for processing
mark_doneMark message as processed
search_messagesSemantic + metadata search
create_channelCreate public/private channel
join_channelJoin a public channel
list_channelsList available channels
discover_agentsFind agents by capability
post_taskPost a task for auction
bid_taskBid on an open task

Architecture

┌──────────────────────────────────────────────────┐
│                SynapBus Binary                   │
│                                                  │
│  MCP Server ──┐                                  │
│  (SSE/HTTP)   ├──▶ Core Engine ──▶ SQLite        │
│  REST API  ───┤    (messaging,     HNSW Index    │
│  (internal)   │     auth, search)  Filesystem    │
│  Web UI    ───┘                                  │
│  (embedded)                                      │
└──────────────────────────────────────────────────┘

Configuration

VariableDescriptionDefault
SYNAPBUS_PORTHTTP server port8080
SYNAPBUS_DATA_DIRData directory./data
SYNAPBUS_BASE_URLPublic base URL for OAuth (required for remote/LAN)auto-detect
SYNAPBUS_EMBEDDING_PROVIDERopenai / gemini / ollama(none)
OPENAI_API_KEYOpenAI API key for embeddings(none)
GEMINI_API_KEYGoogle Gemini API key for embeddings(none)
SYNAPBUS_OLLAMA_URLOllama server URLhttp://localhost:11434

OAuth & MCP Authentication

SynapBus is its own OAuth 2.1 identity provider. MCP clients (Claude Code, Gemini CLI, etc.) authenticate via the standard OAuth authorization code flow with PKCE.

How it works:

  1. MCP client discovers OAuth endpoints via GET /.well-known/oauth-authorization-server
  2. Client registers dynamically via POST /oauth/register (RFC 7591)
  3. User logs in through the SynapBus Web UI, selects an agent identity
  4. Client receives an access token and uses it for MCP tools/call requests

Local setup (default) — no extra config needed:

./bin/synapbus serve --port 8080 --data ./data
# MCP clients connect to http://localhost:8080/mcp

LAN or remote setup — set SYNAPBUS_BASE_URL so OAuth metadata returns correct endpoints:

# On a LAN server
SYNAPBUS_BASE_URL=http://192.168.1.100:8080 ./bin/synapbus serve --data ./data

# Behind a reverse proxy with TLS
SYNAPBUS_BASE_URL=https://synapbus.example.com ./bin/synapbus serve --data ./data

MCP client configuration (e.g., ~/.claude/mcp_config.json):

{
  "mcpServers": {
    "synapbus": {
      "type": "url",
      "url": "http://localhost:8080/mcp"
    }
  }
}

For remote servers, replace localhost:8080 with the server address. OAuth login will open in your browser automatically.

Tech Stack

  • Go 1.23+ — single binary, zero CGO
  • modernc.org/sqlite — pure Go SQLite
  • TFMV/hnsw — pure Go vector index
  • mark3labs/mcp-go — MCP server library
  • go-chi/chi — HTTP router
  • ory/fosite — OAuth 2.1
  • Svelte 5 + Tailwind — Web UI (embedded)

License

Apache 2.0

Server Config

{
  "mcpServers": {
    "synapbus": {
      "url": "http://localhost:8088/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
Project Info
Created At
2 months ago
Updated At
2 months ago
Author Name
Algis Dumbris
Star
-
Language
-
License
-
Category

Recommend Servers

View All
Pipeworx

12 hours ago
Context Repo Mcp Server
@ContextRepo

*One workspace for your prompts, documents, and collections — accessible from every AI client you use.* Context Repo is an AI context management platform for capturing, organizing, versioning, and searching the knowledge artifacts you use with AI tools. This MCP server exposes **28 tools** that give Claude, Cursor, ChatGPT, Factory, Windsurf, Codex, Claude Code, and any other MCP-compatible client direct read-and-write access to your personal workspace — no copy-paste, no context loss between conversations. ## Features - **Prompts** — Full CRUD with version history, rollback, and semantic search across your prompt library - **Documents** — Markdown and plain-text storage with automatic chunking and 1536-dim vector embeddings - **Collections** — Named folders that group prompts and documents into project-scoped contexts - **Catalog Search** — `find_items` returns ranked results across prompts, documents, and collections in a single call (semantic by default, literal fallback) - **Deep Search** — Hierarchical document navigation: search ranked passages, then expand up to parents, down to children, or sideways to siblings for token-efficient exploration of long content - **Version History** — Every content edit creates a new version; restore any prompt or document to any previous state - **Real-time Sync** — Changes propagate instantly via Convex live queries; AI clients always see the latest content - **ChatGPT Apps Ready** — `search` and `fetch` are OpenAI Apps SDK Company-Knowledge eligible; `find_items` carries an optional `ui://` resource for inline result rendering ## Tools (28 total) | Category | Tools | |---|---| | User Info (1) | `get_user_info` | | Prompts (7) | `search_prompts` · `read_prompt` · `create_prompt` · `update_prompt` · `delete_prompt` · `get_prompt_versions` · `restore_prompt_version` | | Documents (7) | `list_documents` · `get_document` · `create_document` · `update_document` · `delete_document` · `get_document_versions` · `restore_document_version` | | Collections (7) | `list_collections` · `get_collection` · `create_collection` · `update_collection` · `delete_collection` · `add_to_collection` · `remove_from_collection` | | Catalog (1) | `find_items` | | Deep Search (3) | `deep_search` · `deep_read` · `deep_expand` | | ChatGPT Apps (2) | `search` · `fetch` | ## Authentication Two ways to connect: 1. **API Key** — Generate a scoped `gm_*` key at [contextrepo.com/dashboard/settings](https://contextrepo.com/dashboard/settings). Per-key permissions: `prompts.read`, `prompts.write`, `documents.read`, `documents.write`, `documents.scrape`. Sent as `Authorization: Bearer gm_...`. 2. **Clerk OAuth 2.0** — RFC 9728 protected-resource metadata at `/.well-known/oauth-protected-resource/mcp`, RFC 8414 authorization-server metadata at `/.well-known/oauth-authorization-server`. Standard OAuth flow for clients that support it. ## Use Cases - **Prompt library that follows you.** Stop copy-pasting prompts between Claude, Cursor, and ChatGPT. Maintain one canonical version, retrieve it from any client. - **Personal knowledge base.** Save research articles, documentation, and AI conversations with the [Context Repo Chrome Extension](https://contextrepo.com/chrome-extension), then pull them in as grounded context inside your AI tools. - **Project-scoped collections.** Separate workspaces per client, repo, or topic so an AI assistant only sees what's relevant to the task at hand. - **Version-controlled prompts.** Track how prompts evolve, A/B test variants, and roll back when an "improvement" turns out worse. - **Long-document exploration.** Deep Search navigates book-length documents passage by passage instead of dumping them into context — every chunk carries parent/child/sibling links the agent can walk. ## Compatibility Streamable HTTP transport, MCP spec ≥ 2025-03-26. Verified with Claude Desktop, Cursor, ChatGPT (via the OpenAI Apps SDK), Factory, Windsurf, Codex, Claude Code, VS Code (Continue), and Amp. Any MCP-compatible client should work. ## Resources - Website: [contextrepo.com](https://contextrepo.com) - Documentation: [contextrepo.com/docs](https://contextrepo.com/docs) - Pricing & free trial: [contextrepo.com/pricing](https://contextrepo.com/pricing) - Agent discovery: [contextrepo.com/llms.txt](https://contextrepo.com/llms.txt) - API reference: [contextrepo.com/openapi.json](https://contextrepo.com/openapi.json)

10 hours ago
Coinrebate

2 hours ago
Taiwan Jobs

a day ago
Datagrout

12 hours ago